From Out-Place Transformation Evolution to In-Place Model Patching

Model transformation is a key technique to automate software engineering tasks. Like any other software, transformations are not resilient to change. As changes to transformations can invalidate previously produced models, these changes need to be reflected on existing models. Currently, revised out-place transformations are re-executed entirely to achieve this co-evolution task. However, this induces an unnecessary overhead, particularly when computation- intensive transformations are marginally revised, and if existing models have undergone updates prior the re-execution, these updates get discarded in the newly produced models. To overcome this co-evolution challenge, our idea is to infer from evolved out-place transformations patch transformations that propagate changes to existing models by re-executing solely the affected parts based on an in-place execution strategy. Thereby, existing models are only updated by a patch instead of newly produced. In this paper, we present the conceptual foundation of our approach and report on its evaluation in a real-world case study.European Commission ICT Policy Support Programme 31785

Reverse engineering of model transformations for reusability

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-319-08789-4_14Proceedings of 7th International Conference, ICMT 2014, Held as Part of STAF 2014, York, UK, July 21-22, 2014Reuse techniques are key for the industrial adoption of Model-Driven Engineering (MDE). However, while reusability has been successfully applied to programming languages, its use is scarce in MDE and, in particular, in model transformations. In previous works, we developed an approach that enables the reuse of model transformations for different meta-models. This is achieved by defining reusable components that encapsulate a generic transformation template and expose an interface called concept declaring the structural requirements that any meta-model using the component should fulfil. Binding the concept to one of such meta-models induces an adaptation of the template, which becomes applicable to the meta-model. To facilitate reuse, concepts need to be concise, reflecting only the minimal set of requirements demanded by the transformation. In this paper, we automate the reverse engineering of existing transformations into reusable transformation components. To make a transformation reusable, we use the information obtained from its static analysis to derive a concept that is minimal with respect to the transformation and maximizes its reuse opportunities, and then evolve the transformation accordingly. The paper describes a prototype implementation and an evaluation using transformations from the ATL zoo.This work has been funded by the Spanish Ministry of Economy and Competitivity with project “Go Lite” (TIN2011-24139

Reusable model transformation components with bentō

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-319-21155-8_5Building high-quality transformations that can be used in real projects is complex and time-consuming. For this reason, the ability to reuse existing transformations in different, unforeseen scenarios is very valuable. However, there is scarce tool support for this task. This paper presents bentō, a tool which supports the development and execution of reusable transformation components. In bentō, a reusable transformation is written as a regular ATL transformation, but it uses concepts as meta-models. Reuse is achieved by binding such concepts to meta-models, which induces the transformation adaptation. Moreover, composite components enable chaining transformations, and it is possible to convert an existing transformation into a reusable component. Bentō is implemented as an Eclipse plug-in, available as free software.This work was supported by the Spanish Ministry of Economy and Competitivity with project Go-Lite (TIN2011-24139), the R&D programme of the Madrid Region with project (SICOMORO S2013/ICE-3006), and the EU commission with project MONDO (FP7-ICT 2013-10, #611125)

The program is the model: Enabling [email protected]

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-642-36089-3_7Revised Selected Papers of 5th International Conference, SLE 2012, Dresden, Germany, September 26-28, 2012The increasing application of Model-Driven Engineering in a wide range of domains, in addition to pure code generation, raises the need to manipulate models at runtime, as part of regular programs. Moreover, certain kinds of programming tasks can be seen as model transformation tasks, and thus we could take advantage of model transformation technology in order to facilitate them. In this paper we report on our works to bridge the gap between regular programming and model transformation by enabling the manipulation of Java APIs as models. Our approach is based on the specification of a mapping between a Java API (e.g., Swing) and a meta-model describing it. A model transformation definition is written against the API meta-model and we have built a compiler that generates the corresponding Java bytecode according to the mapping. We present several application scenarios and discuss the mapping between object-oriented meta-modelling and the Java object system. Our proposal has been validated by a prototype implementation which is also contributed.Work funded by the Spanish Ministry of Economy and Competitivity (TIN2011-24139), and the R&D programme of Madrid Region (S2009/TIC-1650)

Towards the systematic construction of domain-specific transformation languages

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-319-09195-2-13Proceedings of 10th European Conference, ECMFA 2014, Held as Part of STAF 2014, York, UK, July 21-25, 2014General-purpose transformation languages, like ATL or QVT, are the basis for model manipulation in Model-Driven Engineering (MDE). However, as MDE moves to more complex scenarios, there is the need for specialized transformation languages for activities like model merging, migration or aspect weaving, or for specific domains of wide use like UML. Such domain-specific transformation languages (DSTLs) encapsulate transformation knowledge within a language, enabling the reuse of recurrent solutions to transformation problems. Nowadays, many DSTLs are built in an ad-hoc manner, which requires a high development cost to achieve a full-featured implementation. Alternatively, they are realised by an embedding into general-purpose transformation or programming languages like ATL or Java. In this paper, we propose a framework for the systematic creation of DSTLs. First, we look into the characteristics of domain-specific transformation tools, deriving a categorization which is the basis of our framework. Then, we propose a domain-specific language to describe DSTLs, from which we derive a ready-to-run workbench which includes the abstract syntax, concrete syntax and translational semantics of the DSTL.This work has been funded by the Spanish Ministry of Economy and Competitivity with project “Go Lite” (TIN2011-24139

Using metrics for assessing the quality of ATL model transformations

Model transformations play a pivotal role in model-driven engineering. Since they are in many ways similar to traditional software artifacts, they have to be treated similarly. Therefore, it is necessary to assess their quality. We propose to use metrics to assess various quality attributes of model transformations In this paper, we focus on model transformations created using ATL, which ATL is currently one of the most widely used model transformation formalisms. We have collected metrics data from a heterogeneous collection of seven model transformations. The quality of the same transformations has been evaluated manually by nineteen ATL experts. We assess whether the metrics are appropriate predictors for the quality attributes by correlating the metrics data with the expert data. To support or refute the correlations, we also acquired qualitative statements from the ATL experts. Although the study was intended as a first exploration of the relation between metrics and quality attributes, some significant correlations were found that are supported by statements of the participants

Towards Functional Model Transformations with OCL

International audienceSeveral model transformation approaches such as QVT and ATL use OCL as expression language for its model-querying capabilities. However, they need to add specific and incompatible syntactic constructs for pattern matching as well as model element creation and mutation.In this paper, we present an exploratory approach to enable the expression of whole model transformations in OCL. This approach leverages some OCL extensions proposed for inclusion in the upcoming OCL 2.5: pattern matching and shadow objects. It also relies on a specific execution layer to enable traceability and side effects on models.With model transformations as OCL functions, it becomes possible to use a single, standard, well-known, functional, and formalized model querying language to perform tasks traditionally assigned to model transformation languages. Thus, functional techniques such as function composition and higher-order become directly applicable to model transformations